package thread;

/*public class SyncDemo1 {
    public static void main(String[] args) {
        Shop shop = new Shop();
        Thread t1 = new Thread("王克晶"){
            public void run() {
                shop.buy();
            }
        };
        Thread t2 = new Thread("范传奇"){
            public void run(){
                shop.buy();
            }
        };
        t1.start();
        t2.start();
      *//*  Shop shop1 = new Shop();
        Shop shop2 = new Shop();
        Thread t1 = new Thread("王克晶"){
            @Override
            public void run() {
                shop1.buy();
            }
        };
        Thread t2 = new Thread("范传奇"){
            public void run(){
                shop2.buy();
            }
        };
        t1.start();
        t2.start();*//*
    }

}


class Shop{
    //public  synchronized void buy{在方法上同步监视（加锁）,范围比较大，同步监视对象只能是this
    public  void buy(){
        try {
            Thread t = Thread.currentThread();
            System.out.println(t.getName()+"正在挑衣服");
            Thread.sleep(3000);
            //synchronized (123){
            //synchronized (new Object()){
            //synchronized ("abc"){
            synchronized (this){
                System.out.println(t.getName()+"正在试衣服");
                Thread.sleep(3000);
            }
            System.out.println(t.getName()+":结账离开");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}*/

/**
 * 线程并发问题
 * 同步块：
 *  synchronized(同步监视对象){
 *     需要多个线程同时执行的代码片段（排队执行的）
 * }
 */
public class SyncDemo1 {
    public static void main(String[] args) {
        Shop shop = new Shop();
        Thread t1 = new Thread("王克晶"){
            public void run() {
                shop.buy();
            }
        };
        Thread t2 = new Thread("范传奇"){
            public void run(){
                shop.buy();
            }
        };
        t1.start();
        t2.start();
    }
}

class Shop{
    //public synchronized void buy(){//在方法上同步监视（加锁）,范围比较大，同步监视对象只能是this
    public void buy(){
        try {
            Thread t = Thread.currentThread();//获取当前线程对象
            System.out.println(t.getName()+"：正在挑衣服");
            Thread.sleep(3000);//sleep方法是静态的，应该通过类名Thread来调用;
            /*
             同步监视对象可以是任意对象，但是必须是同一个对象，否则无法同步
             同步监视块，缩小了监视范围
             同步监视对象通常使用：临界资源
             临界资源：抢谁谁就是临界资源，说白了，抢谁就锁谁
             */
            //synchronized(this){//同步监视对象一定是引用类型
            //synchronized (new Object()){//永远不能用实例化的对象作为同步监视对象，因为实例化的对象不确定，可能指向null，可能指向其他对象，所以不能用实例化的对象作为同步监视对象，而同步监视对象必须是同一个对象
            synchronized ("abc"){//虽然可以锁上，但是abc不是合适的锁对象
            //synchronized(this){//this是同步监视对象，范围比较小，同步监视对象可以是任意对象,this是当前对象，当前对象是shop对象
                System.out.println(t.getName()+"：正在试衣服");
                Thread.sleep(3000);//和Thread.currentThread().sleep(3000);是等价的
            }
            System.out.println(t.getName()+":结账离开了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}